
namespace Xunit

module FSharp =
    
    let be (f : 'a -> unit) actual =
      f actual
    
    let False condition =
        Assert.False(condition)
    
    let True condition =
        Assert.True(condition)
      
    let Empty collection =
        Assert.Empty(collection)
      
    let NonEmpty collection =
        Assert.NotEmpty(collection)
      
    let Null item =
        Assert.Null(item)
      
    let NonNull item =
        Assert.NotNull(item)
      
    let equal expected actual =
        Assert.Equal(expected, actual)
    
    let notEqual expected actual =
        Assert.NotEqual(expected, actual)
    
    let contain (expected : string) (actual : string) =
        Assert.Contains(expected, actual)
      
    let notContain expected actual =
        Assert.DoesNotContain((expected:string), (actual:string))
    
    let have expected actual =
        Assert.Contains(expected, (actual :> seq<_>))
      
    let notHave expected actual =
        Assert.DoesNotContain(expected, (actual :> seq<_>))
      
    let beSameAs expected actual =
        Assert.Same(expected, actual)
      
    let notBeSameAs expected actual =
        Assert.NotSame(expected, actual)
      
    let beInRange low high actual =
        Assert.InRange(actual, low, high)
      
    let notBeInRange low high actual =
      Assert.NotInRange(actual, low, high)
      
    let beType<'T> actual =
        Assert.IsType<'T>(actual)
      
    let beAssignableFrom<'T> actual =
        Assert.IsAssignableFrom<'T>(actual)
        
    let throw<'a when 'a :> exn> actual =
        Assert.Throws<'a>(Assert.ThrowsDelegate(actual)) 
      
    let notThrow actual =
        Assert.DoesNotThrow(Assert.ThrowsDelegate(actual))
     
    let should f actual =
        f actual

    
